import axios from 'axios'
import { getSaToken } from '@/utils/auth'

// 设置API基础URL前缀 - 根据后端实际情况配置
const API_BASE_URL = 'http://localhost:5000/EcoQuest';

// 创建 axios 实例
const api = axios.create({
  baseURL: API_BASE_URL,
  timeout: 15000, // 超时时间15秒
  withCredentials: true, // 允许跨域携带 cookie
  headers: {
    'Content-Type': 'application/json',
    'Accept': 'application/json'
  }
})

// 请求拦截器
api.interceptors.request.use(
  config => {
 
    
    // 尝试获取SaToken信息
    const saToken = getSaToken();
    
    if (saToken && saToken.tokenValue) {
      // 添加satoken请求头，格式为 mezhate token值
      config.headers['satoken'] = `mezhate ${saToken.tokenValue}`;
     
    } else {
      // 如果没有token值，使用固定格式
      const token = localStorage.getItem('token');
      if (token) {
        config.headers['satoken'] = `mezhate ${token}`;
    
      } else {
        // 即使没有token，也添加satoken头，值为固定格式
        config.headers['satoken'] = `mezhate token`;
      
      }
    }
    
    return config;
  },
  error => {
    console.error('请求拦截器错误:', error);
    return Promise.reject(error);
  }
)

// 响应拦截器
api.interceptors.response.use(
  response => {
    const res = response.data
    
    // 正常响应
    if (res.code === 200) {
      return res
    }
    
    // 处理错误
    console.error('API请求失败:', res.message || '未知错误')
    return Promise.reject(new Error(res.message || '未知错误'))
  },
  error => {
    console.error('请求响应错误:', error)
    return Promise.reject(error)
  }
)

// 保留模拟数据，但只在mock模式下使用
const mockTaskDetail = {
  code: 200,
  data: {
    id: 1,
    taskName: '7天低碳生活挑战',
    taskDescription: '通过连续7天的低碳生活方式，减少个人碳足迹，获得积分奖励。',
    taskType: '低碳生活',
    taskStatus: 1, // 0-未开始，1-进行中，2-已完成，3-已过期
    taskDifficulty: 1, // 0-简单，1-中等，2-困难
    startTime: '2023-11-01',
    endTime: '2023-11-07',
    pointReward: 200,
    participantCount: 156,
    participantAvatars: [
      '/images/avatars/user1.jpg',
      '/images/avatars/user2.jpg',
      '/images/avatars/user3.jpg'
    ],
    isParticipating: true,
    tasks: [
      {
        day: 1,
        title: '步行或骑车出行',
        description: '今天选择步行、骑自行车或使用公共交通工具代替开车。',
        isCompleted: true,
        exampleImage: '/images/tasks/walking.jpg'
      },
      {
        day: 2,
        title: '减少用水量',
        description: '今天洗澡时间缩短2分钟，并确保关紧水龙头。',
        isCompleted: true,
        exampleImage: '/images/tasks/water.jpg'
      },
      {
        day: 3,
        title: '无肉日',
        description: '今天不食用肉类，尝试素食菜单。',
        isCompleted: false,
        exampleImage: '/images/tasks/vegetarian.jpg'
      },
      {
        day: 4,
        title: '减少塑料使用',
        description: '今天不使用一次性塑料制品，带上可重复使用的水杯和购物袋。',
        isCompleted: false,
        exampleImage: '/images/tasks/plastic.jpg'
      },
      {
        day: 5,
        title: '节约用电',
        description: '今天减少1小时电器使用时间，并确保不使用时关闭所有电器。',
        isCompleted: false,
        exampleImage: '/images/tasks/electricity.jpg'
      },
      {
        day: 6,
        title: '零浪费日',
        description: '今天尽量不产生垃圾，重复使用物品，合理规划食物。',
        isCompleted: false,
        exampleImage: '/images/tasks/zerowaste.jpg'
      },
      {
        day: 7,
        title: '环保宣传',
        description: '向朋友或家人分享你的低碳生活经验，鼓励他们也参与进来。',
        isCompleted: false,
        exampleImage: '/images/tasks/share.jpg'
      }
    ],
    rankings: [
      { rank: 1, name: '张三', avatar: '/images/avatars/user1.jpg', score: 350 },
      { rank: 2, name: '李四', avatar: '/images/avatars/user2.jpg', score: 320 },
      { rank: 3, name: '王五', avatar: '/images/avatars/user3.jpg', score: 300 }
    ],
    knowledge: [
      {
        id: 1,
        title: '什么是碳足迹?',
        content: '碳足迹是指个人、组织或产品在一段时间内直接或间接产生的温室气体总量。',
        link: '/knowledge/carbon-footprint'
      },
      {
        id: 2,
        title: '如何减少日常碳排放',
        content: '通过改变日常习惯，如减少肉类消费、选择公共交通和节约用电等方式，可以有效减少个人碳排放。',
        link: '/knowledge/reduce-emissions'
      }
    ],
    posts: [
      {
        id: 1,
        author: '张三',
        avatar: '/images/avatars/user1.jpg',
        time: '2小时前',
        content: '今天是我挑战的第3天，感觉素食其实挺好吃的！分享一个我做的素食沙拉。',
        image: '/images/posts/salad.jpg',
        likes: 12,
        comments: 3
      }
    ],
    faqs: [
      {
        id: 1,
        question: '如何计算我的碳排放量?',
        answer: '您可以使用我们的碳计算器，输入您的日常活动数据，如出行方式、用电量和饮食习惯等，系统会自动计算您的碳排放量。'
      },
      {
        id: 2,
        question: '完成挑战后的积分如何使用?',
        answer: '您获得的积分可以在积分商城兑换环保产品、电子优惠券或捐赠给环保项目。'
      }
    ]
  }
};

const mockTaskList = {
  code: 200,
  data: {
    total: 3,
    list: [
      {
        id: 1,
        taskName: '7天低碳生活挑战',
        taskDescription: '通过连续7天的低碳生活方式，减少个人碳足迹，获得积分奖励。',
        taskType: '低碳生活',
        taskStatus: 1,
        taskDifficulty: 1,
        startTime: '2023-11-01',
        endTime: '2023-11-07',
        pointReward: 200,
        participantCount: 156,
        coverImage: '/images/challenges/challenge1.jpg'
      },
      {
        id: 2,
        taskName: '垃圾分类达人',
        taskDescription: '学习并实践正确的垃圾分类方法，提高资源回收利用率。',
        taskType: '资源回收',
        taskStatus: 0,
        taskDifficulty: 0,
        startTime: '2023-11-10',
        endTime: '2023-11-17',
        pointReward: 150,
        participantCount: 89,
        coverImage: '/images/challenges/challenge2.jpg'
      },
      {
        id: 3,
        taskName: '节能月挑战',
        taskDescription: '30天内通过各种方法减少家庭能源消耗，监测并记录节能效果。',
        taskType: '节能减排',
        taskStatus: 2,
        taskDifficulty: 2,
        startTime: '2023-10-01',
        endTime: '2023-10-31',
        pointReward: 300,
        participantCount: 210,
        coverImage: '/images/challenges/challenge3.jpg'
      }
    ]
  }
};

/**
 * 获取任务详情
 * @param {Number} id - 任务ID
 * @returns {Promise} 任务详情数据
 */
export function getTaskDetail(id) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
    console.log('使用模拟数据返回任务详情');
    return Promise.resolve(mockTaskDetail);
  }
  
  // 简化请求对象，只包含ID
  const taskDTO = { id: id };
  
  // 使用正确的后端API路径并确保发送JSON格式
  return api.post('/task/getTask', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      // 处理API返回的数据
      if (response && response.data) {
        // 为任务ID=1的情况设置固定的16天
        if (id === 1 || id === '1') {
          response.data.totalDays = 16;
        } else {
          // 计算任务持续天数
          if (response.data.startTime && response.data.endTime) {
            const startDate = new Date(response.data.startTime);
            const endDate = new Date(response.data.endTime);
            // 计算时间差并转换为天数
            const timeDiff = Math.abs(endDate.getTime() - startDate.getTime());
            const daysDiff = Math.ceil(timeDiff / (1000 * 3600 * 24));
            
            // 添加计算出的天数到响应数据中
            response.data.totalDays = daysDiff;
          }
        }
        
        // 确保积分奖励(points)正确显示
        if (response.data.points !== undefined) {
          response.data.pointReward = response.data.points;
        }
        
        // 确保参与人数(hot)正确显示
        if (response.data.hot !== undefined) {
          response.data.participantCount = response.data.hot;
        }
      }
      
      return response;
    })
    .catch(error => {
      console.error('获取任务详情失败:', error);
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        return mockTaskDetail;
      }
      return Promise.reject(error);
    });
}

/**
 * 获取任务列表
 * @param {Object} params - 查询参数
 * @param {Number} params.pageNo - 页码，默认为1
 * @param {Number} params.pageSize - 每页条数，默认为9
 * @returns {Promise} 任务列表数据
 */
export function getTaskList(params = {}) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {

    return Promise.resolve(mockTaskList);
  }
  
  // 确保请求中包含分页参数
  const requestData = {
    pageNo: params.pageNo || 1,
    pageSize: params.pageSize || 9,
    ...params  // 保留其他可能的过滤参数
  };
  

  
  // 使用正确的后端API路径并确保发送JSON格式
  return api.post('/task/getTaskList', requestData, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
    
      
      // 检查响应数据的结构
      if (response.data) {

        // 处理后端特定的响应结构
        if (response.data.success === true && response.data.code === 200 && response.data.data) {
          return response.data; // 返回整个响应，让组件处理具体数据抽取
        }
        
      }
      
      return response;
    })
    .catch(error => {
      console.error('获取任务列表失败:', error);
      console.error('错误详情:', error.response ? error.response.data : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        return mockTaskList;
      }
      return Promise.reject(error);
    });
}

/**
 * 参与任务/挑战
 * @param {Number} taskId - 任务ID
 * @returns {Promise} 参与结果
 */
export function joinTask(taskId) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {

    return Promise.resolve({
      code: 200,
      data: {
        success: true,
        message: '成功参与任务'
      }
    });
  }
  
  if (!taskId || isNaN(taskId)) {
    console.error('无效的任务ID:', taskId);
    return Promise.reject(new Error('无效的任务ID'));
  }
  
  const taskDTO = { taskId: taskId };
  

  
  // 使用正确的后端API路径
  return api.post('/taskUser/add', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
   
      // 确保返回正确的响应格式
      return response;
    })
    .catch(error => {
      console.error('参与任务失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
     
        return {
          code: 200,
          data: {
            success: true,
            message: '成功参与任务'
          }
        };
      }
      
      return Promise.reject(error);
    });
}

/**
 * 检查用户是否已接受特定挑战任务
 * @param {Number} taskId - 任务ID
 * @returns {Promise} 接受状态
 */
export function isTaskAccepted(taskId) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {

    // 随机返回true或false以便测试
    return Promise.resolve({
      code: 200,
      data: Math.random() > 0.5
    });
  }
  
  if (!taskId || isNaN(taskId)) {
    console.error('无效的任务ID:', taskId);
    return Promise.reject(new Error('无效的任务ID'));
  }
  
  // 构造请求对象
  const taskDTO = { taskId: taskId };
  

  // 将GET请求改为POST请求，使用请求体而不是URL参数
  return api.post('/taskUser/isTask', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log('检查任务接受状态响应:', response);
      return response;
    })
    .catch(error => {
      console.error('检查任务接受状态失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        console.log('返回模拟结果');
        return {
          code: 200,
          data: false
        };
      }
      
      return Promise.reject(error);
    });
}

/**
 * 放弃任务/挑战
 * @param {Number} taskId - 任务ID
 * @returns {Promise} 放弃结果
 */
export function abandonTask(taskId) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
 
    return Promise.resolve({
      code: 200,
      data: {
        success: true,
        message: '成功放弃任务'
      }
    });
  }
  
  if (!taskId || isNaN(taskId)) {
    console.error('无效的任务ID:', taskId);
    return Promise.reject(new Error('无效的任务ID'));
  }
  
  const taskDTO = { taskId: taskId };
  
  // 使用正确的后端API路径 - 需要后端提供这个接口
  return api.post('/taskUser/abandon', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
    
      return response;
    })
    .catch(error => {
      console.error('放弃任务失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
 
        return {
          code: 200,
          data: {
            success: true,
            message: '成功放弃任务'
          }
        };
      }
      
      return Promise.reject(error);
    });
}

/**
 * 获取用户接受挑战的天数
 * @param {Number} taskId - 任务ID
 * @returns {Promise} 包含用户接受挑战天数的响应
 */
export function getTaskDays(taskId) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
    console.log('使用模拟数据返回接受挑战天数');
    const mockData = {
      code: 200,
      data: {
        days: 5  // 模拟数据：用户已接受挑战5天
      }
    };
    console.log('返回模拟数据:', JSON.stringify(mockData, null, 2));
    return Promise.resolve(mockData);
  }
  
  if (!taskId || isNaN(taskId)) {
    console.error('无效的任务ID:', taskId);
    return Promise.reject(new Error('无效的任务ID'));
  }
  
  const taskUserDTO = { taskId: taskId };
  console.log('调用queryDays API，请求参数:', JSON.stringify(taskUserDTO, null, 2));
  
  // 调用新接口 queryDays
  return api.post('/taskUser/queryDays', taskUserDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log('queryDays API原始响应:', response);
      console.log('queryDays API响应数据:', JSON.stringify(response, null, 2));
      
      // 检查响应中是否包含days字段
      if (response && response.data) {
        console.log('天数数据:', response.data.days);
        console.log('天数数据类型:', typeof response.data.days);
      }
      
      return response;
    })
    .catch(error => {
      console.error('获取任务接受天数失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      console.error('错误消息:', error.message);
      console.error('错误堆栈:', error.stack);
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        console.log('由于错误，返回备用模拟结果');
        const fallbackData = {
          code: 200,
          data: {
            days: 3  // 模拟数据：用户已接受挑战3天
          }
        };
        console.log('返回备用数据:', JSON.stringify(fallbackData, null, 2));
        return fallbackData;
      }
      
      return Promise.reject(error);
    });
}

/**
 * 任务打卡
 * @param {Number} taskId - 任务ID
 * @returns {Promise} 打卡结果，true表示打卡成功（首次打卡），false表示今天已经打过卡
 */
export function clockTask(taskId) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
    console.log('使用模拟数据返回打卡结果');
    // 随机返回true或false模拟不同情况
    const isSuccess = Math.random() > 0.3;
    const mockData = {
      code: 200,
      data: isSuccess  // 模拟数据：70%概率打卡成功，30%概率已打卡
    };
    console.log('返回模拟打卡数据:', JSON.stringify(mockData, null, 2));
    return Promise.resolve(mockData);
  }
  
  if (!taskId || isNaN(taskId)) {
    console.error('无效的任务ID:', taskId);
    return Promise.reject(new Error('无效的任务ID'));
  }
  
  const taskUserDTO = { taskId: taskId };
  console.log('调用clock API，请求参数:', JSON.stringify(taskUserDTO, null, 2));
  
  // 调用打卡接口
  return api.post('/taskUser/clock', taskUserDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log('clock API原始响应:', response);
      console.log('clock API响应数据:', JSON.stringify(response, null, 2));
      
      // 检查响应
      if (response && response.code === 200) {
        console.log('打卡结果:', response.data);
        console.log('打卡结果类型:', typeof response.data);
      }
      
      return response;
    })
    .catch(error => {
      console.error('打卡失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      console.error('错误消息:', error.message);
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        console.log('由于错误，返回备用模拟结果');
        const fallbackData = {
          code: 200,
          data: false  // 模拟失败情况
        };
        console.log('返回备用打卡数据:', JSON.stringify(fallbackData, null, 2));
        return fallbackData;
      }
      
      return Promise.reject(error);
    });
}

/**
 * 修改任务/挑战
 * @param {Object} taskDTO - 任务数据对象，必须包含id字段
 * @returns {Promise} 修改结果
 */
export function updateTask(taskDTO) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
    console.log('使用模拟数据返回更新任务结果');
    return Promise.resolve({
      code: 200,
      data: {
        ...taskDTO,
        success: true,
        message: '成功更新任务'
      }
    });
  }
  
  if (!taskDTO || !taskDTO.id) {
    console.error('无效的任务数据:', taskDTO);
    return Promise.reject(new Error('任务ID不能为空'));
  }
  
  console.log('调用updateTask API，请求参数:', JSON.stringify(taskDTO, null, 2));
  
  // 调用更新任务接口
  return api.post('/task/updateTask', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log('updateTask API响应:', response);
      return response;
    })
    .catch(error => {
      console.error('更新任务失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        console.log('由于错误，返回模拟结果');
        return {
          code: 200,
          data: {
            ...taskDTO,
            success: true,
            message: '成功更新任务'
          }
        };
      }
      
      return Promise.reject(error);
    });
}

/**
 * 删除任务/挑战
 * @param {Number|Object} taskIdOrDTO - 任务ID或包含id字段的对象
 * @returns {Promise} 删除结果
 */
export function deleteTask(taskIdOrDTO) {
  // 检查是否使用模拟数据
  const useMock = new URLSearchParams(window.location.search).has('mock');
  
  if (useMock) {
    console.log('使用模拟数据返回删除任务结果');
    return Promise.resolve({
      code: 200,
      data: true,
      message: '成功删除任务'
    });
  }
  
  // 处理输入参数，统一转换为包含id的对象
  let taskDTO;
  if (typeof taskIdOrDTO === 'number' || typeof taskIdOrDTO === 'string') {
    taskDTO = { id: Number(taskIdOrDTO) };
  } else if (taskIdOrDTO && taskIdOrDTO.id) {
    taskDTO = taskIdOrDTO;
  } else {
    console.error('无效的任务ID:', taskIdOrDTO);
    return Promise.reject(new Error('任务ID不能为空'));
  }
  
  console.log('调用deleteTask API，请求参数:', JSON.stringify(taskDTO, null, 2));
  
  // 调用删除任务接口
  return api.post('/task/deleteTask', taskDTO, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log('deleteTask API响应:', response);
      // 处理可能包含alert/confirm触发字符串的响应
      if (response && response.message) {
        // 保留信息但不让消息触发原生的alert
        console.log('删除任务成功:', response.message);
        return {
          ...response,
          // 删除或替换可能触发alert的字段
          alertMessage: response.message,
          message: undefined
        };
      }
      return response;
    })
    .catch(error => {
      console.error('删除任务失败:', error);
      console.error('错误详情:', error.response ? JSON.stringify(error.response.data) : '无响应数据');
      
      if (useMock || new URLSearchParams(window.location.search).has('fallback')) {
        console.log('由于错误，返回模拟结果');
        return {
          code: 200,
          data: true,
          alertMessage: '成功删除任务',
          message: undefined
        };
      }
      
      return Promise.reject(error);
    });
}

export default {
  getTaskDetail,
  getTaskList,
  joinTask,
  isTaskAccepted,
  abandonTask,
  getTaskDays,
  clockTask,
  updateTask,
  deleteTask
} 